home *** CD-ROM | disk | FTP | other *** search
/ PC Media 23 / PC MEDIA CD23.iso / share / prog / anubis / comunica.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-04  |  11.4 KB  |  302 lines
  1. // COMUNICA.H
  2. // (C) Anubis Software Noviembre 1994
  3. // Libreria para el uso de comunicaciónes entre distintos ordenadores.
  4. #ifndef COMUNICA.H
  5. #define COMUNICA.H
  6.  
  7. // NOTAS DE LA LIBRERIA.
  8. // ----------------------
  9. // Esta librería es el interface de todo el servicio de gestión de los
  10. // puertos de comunicaciones de la Bios. Todas las funciones implementadas
  11. // en ella, son simples llamadas a una interrupción de la Bios.
  12. // Por este motivo existen ciertos agujeros en lo que a eficiencia de la
  13. // librería se refiere. (No es aconsejable usar este sistema para más de 2400 baudios)
  14. // pués podría suceder que se perdiesen caracteres por el camino.
  15. //
  16. // Pero  se proporciona un buén interfaz de apoyo a las comunicaciones asincronas por el
  17. // puerto serie del ordenador.
  18.  
  19.  
  20. // ------------------------------------+
  21. // Inclusión de librerías Borland C++  |
  22. // ------------------------------------+
  23. #include <conio.h>
  24. #include <stdio.h>
  25.  
  26. // ------------------------------------------------------------------+
  27. // Definición de constantes útiles para las funciones simplificadas. |
  28. // ------------------------------------------------------------------+
  29.  
  30. // Constantes que deben utilizarse con prep_comunicacion
  31. #define _110_BAUDIOS 0
  32. #define _150_BAUDIOS 32
  33. #define _300_BAUDIOS 64
  34. #define _600_BAUDIOS 96
  35. #define _1200_BAUDIOS 128
  36. #define _2400_BAUDIOS 160
  37. #define _4800_BAUDIOS 192
  38. #define _9600_BAUDIOS 224
  39. #define _SIN_PARIDAD 0
  40. #define _PARIDAD_IMPAR 8
  41. #define _PARIDAD_PAR 24
  42. #define _1_BIT_PARADA 0
  43. #define _2_BIT_PARADA 4
  44. #define _7_BITS_LONG_PALABRA 2
  45. #define _8_BITS_LONG_PALABRA 3
  46. // Definición de constantes útiles para las funciones completas.
  47. // Constantes que deben utilizarse con prep_comp_comunicacion
  48. #define SIN_INTERRUPCION                            0
  49. #define CON_INTERRUPCION                            1
  50. #define NO_PARIDAD                                  0
  51. #define IMPAR_PARIDAD                               1
  52. #define PAR_PARIDAD                                 2
  53. #define REP_IMPAR_PARIDAD                           3
  54. #define REP_PAR_PARIDAD                             4
  55. #define STOP_1                                      0
  56. #define STOP_2                                      1
  57. #define STOP_1_5                                    1
  58. #define LONG_5                                      0
  59. #define LONG_6                                      1
  60. #define LONG_7                                      2
  61. #define LONG_8                                      3
  62. #define BAUD_110                                    0
  63. #define BAUD_150                                    1
  64. #define BAUD_300                                    2
  65. #define BAUD_600                                    3
  66. #define BAUD_1200                                   4
  67. #define BAUD_2400                                   5
  68. #define BAUD_4800                                   6
  69. #define BAUD_9600                                   7
  70. #define BAUD_19200                                  8
  71. // Definiciones para la variable registro en las funciones completas.
  72. #define TERMINAL_DATOS_DISPUESTO                    1
  73. #define PETICION_ENVIO                              2
  74. #define SALIDA_1                                    4
  75. #define SALIDA_2                                    8
  76. #define LAZO                                       16
  77. // Definición de los puertos más importantes
  78. #define COM1 0
  79. #define COM2 1
  80. #define COM3 2
  81. #define COM4 3
  82. #define COM5 4
  83. #define COM6 5
  84. #define COM7 6
  85. #define COM8 7
  86. #define COM9 8
  87. // Definición de los estados más comunes del puerto de comunicación.
  88. #define CAMBIO_ESTADO_ENVIO_BORRADO                 1
  89. #define CAMBIO_ESTADO_ENVIADOR_DATOS                2
  90. #define INDICADOR_FLANCO_LLAMADA                    4
  91. #define DETECCION_CAMBIO_LINEA_RECEPCION            8
  92. #define ENVIAR_BORRADO                             16
  93. #define ENVIADOR_DATOS_LISTO                       32
  94. #define INDICADOR_LLAMADA                          64
  95. #define DETECCION_SEÑAL_RECEPCION                 128
  96. #define DISPUESTO_RECIBIR_DATOS                 (1<<8)
  97. #define DETECTADO_ERROR_SOBREESCRITURA            (2<<8)
  98. #define DETECTADO_ERROR_PARIDAD                 (4<<8)
  99. #define DETECTADO_ERROR_TRAMA                   (8<<8)
  100. #define DETECTADA_INTERRUPCION                 (16<<8)
  101. #define REGISTRO_EXTERNO_TRANSMISION_VACIO     (32<<8)
  102. #define REGISTRO_DESPLAZAMIENTO_SALIDA_VACIO   (64<<8)
  103. #define EXCESO_TIEMPO                         (128<<8)
  104.  
  105. // ------------------------------------------------------------------+
  106. // Definición e implementación de los procedimientos de la librería  |
  107. // ------------------------------------------------------------------+
  108.  
  109. // -------------------------------------------------------------------------
  110. // result = prep_comp_comunicacion (puerto, velocidad, paridad, parada ,
  111. //                                  long_palabra, interrupcion);
  112. //
  113. // int resul         --> Nos da el resultado de preparar la comunicación.
  114. // int puerto        --> Indica el puerto que estamos configurando. (COM1, COM2, etc
  115. // char velocidad    --> Especifica la velocidad en baudios a que configuramos.
  116. // char paridad      --> Especifica los bits de paridad que vamos a utilizar para el puerto.
  117. // char parada       --> Indica los bits de parada que vamos a utilizar 1, 2, 1.5
  118. // char long_palabra --> Indica la longitud en bytes de la palabra.
  119. // char interrupcion --> Indica si se tiene que generar una interrupción cuando recibamos un caracter.
  120. //
  121. // Practicamente en su totalidad, estos argumentos deben usar las constantes definidas de la librería
  122. // que están especificadas arriba.
  123. //
  124. // Esta función configura el puerto serie de comunicaciones de una forma muy completa.
  125. // Para ello utiliza la interrupción 14h de la bios, la cual sirve especialmente para
  126. // ello. (Subfuncion 4h)
  127. // Devuelve el estado del puerto, y el estado del modem.
  128. //
  129. int prep_comp_comunicacion(int puerto, char vel,char paridad,char parada,char long_pal,char interrupcion)
  130. {
  131.    int salida;
  132.    asm mov ah,04h
  133.    asm mov al,interrupcion
  134.    asm mov bh,paridad
  135.    asm mov bl,parada
  136.    asm mov ch,long_pal
  137.    asm mov cl,vel
  138.    asm mov dx,puerto
  139.    asm int 14h
  140.    asm mov salida,ax
  141.    return(salida);
  142. }// end rep_comp_comunicacion
  143.  
  144. // ----------------------------------------------------------------------
  145. // result = control_comunicacion(puerto, registro);
  146. //
  147. // int result    --> Devuelve el resultado de la operación.
  148. // int puerto    --> Indica el puerto del que buscamos el estado (COM1, COM2 , etc)
  149. // char registro --> Ver constantes asociadas (Indican la consulta)
  150. //
  151. // El paso de argumentos, es preferible hacerlo con las constantes definidas.
  152. //
  153. // Esta función establece el estado del puerto de comunicaciones. Para mantener
  154. // un cierto control sobre el mismo.
  155. // Para ello utiliza la interrupción 14h de la Bios (Subfunción 5h)
  156. //
  157. int control_comunicacion(int puerto,char registro)
  158. {
  159.    int salida;
  160.    asm mov ah,05h
  161.    asm mov al,01h
  162.    asm mov bl,registro
  163.    asm mov dx,puerto
  164.    asm int 14h
  165.    asm mov salida,ax
  166.    return(salida);
  167. }// end control comunicacion
  168.  
  169. // ---------------------------------------------------------------------
  170. // result = lee_control_comunicacion (puerto);
  171. //
  172. // char result   --> Es estado del puerto de comunicaciones.
  173. // int puerto    --> Indica de que puerto serie se trata (COM1, COM2 , etc)
  174. //
  175. // Esta función lee el estado del puerto de comunicaciones, para establecer
  176. // un mayor control del mismo.
  177. // Para ello utiliza la interrupción 14h de la Bios (Subfunción 5h)
  178. //
  179. char lee_control_comunicacion(int puerto)
  180. {
  181.    char registro;
  182.    asm mov ah,05h
  183.    asm mov al,00h
  184.    asm mov dx,puerto
  185.    asm int 14h
  186.    asm mov registro,bl
  187.    return(registro);
  188. }// end lee_control_comunicacion
  189.  
  190. // ------------------------------------------------------------------------
  191. // result = prep_comunicacion(puerto, velocidad, paridad, parada, long_pal);
  192. //
  193. // int result     --> Devuelve el estado del puerto de comunicación.
  194. // char velocidad --> Indica la velocidad en baudios a que queremos poner el puerto.
  195. // char paridad   --> Indica como debe ser el control de paridad.
  196. // char parada    --> Indica los bits de STOP que se utilizan. (1 o 2)
  197. // char long_pal  --> Indica la longitud de la palabra a transmitir
  198. //
  199. // Esta función es un subconjunto de pre_comp_comunicacion, con menos opciones,
  200. // pero que según el caso nos será más útil debido a su mayor sencillez.
  201. // Igualmente, prepara el puerto de comunicación serie para mantener comunicación.
  202. // Para ello utiliza la interrupción 14h de la Bios (Subfuncion 00h)
  203. // NOTA: Las constantes en ambas funciones no son las mismas, cambian de una función a otra
  204. // Asi, que no debe haber confusión sobre que constantes deben utilizarse.
  205. // Esta función utiliza todas aquellas que empiezan por el caracter _...
  206. //
  207. int prep_comunicacion(int puerto,char velocidad,char paridad,char bits,char long_pal)
  208. {
  209.     char configuracion;
  210.     int salida;
  211.     configuracion=long_pal | bits | paridad | velocidad;
  212.     asm mov ah,00h
  213.     asm mov al,configuracion
  214.     asm mov dx,puerto
  215.     asm int 14h
  216.     asm mov salida,ax
  217.     return(salida);
  218. }// end prep_comunicacion
  219.  
  220. // -------------------------------------------------------------------------
  221. // result = env_caracter (puerto, caracter);
  222. //
  223. // int result    --> Devuelve 0 si el envio no se realizo, 1 en caso contrario.
  224. // int puerto    --> Indica en que puerto se envia el caracter.
  225. // char caracter --> Este es el caracter que queremos enviar por el puerto.
  226. //
  227. // Esta función, envia un caracter por el puerto serie.
  228. // Para ello utiliza la interrupcion 14h de la Bios, (Subfunción 01h)
  229. //
  230. int env_caracter(int puerto,char caracter)
  231. {
  232.    int salida;
  233.    asm mov ah,01h
  234.    asm mov al,caracter
  235.    asm mov dx,puerto
  236.    asm int 14h
  237.    asm mov salida,ax
  238.    if(salida & (1<<15))
  239.       return(0);
  240.    return(1);
  241. }// end env_caracter
  242.  
  243. // -----------------------------------------------------------------------
  244. // result = lee_caracter(puerto, &caracter);
  245. //
  246. // int result    --> Devuelve 0 si no se pudo enviar el caracter, 1 si fué enviado.
  247. // int puerto    --> Especifica de que puerto en concreto queremos leer el caracter.
  248. // char caracter --> En este lugar estará el caracter leido.
  249. //
  250. // Esta función lee un caracter del puerto serie.
  251. // Para ello utiliza la interrupción 14h de la Bios (Subfunción 02h)
  252. //
  253. int lee_caracter(int puerto,char *caracter)
  254. {
  255.    int salida;
  256.    char car;
  257.    asm mov ah,02h
  258.    asm mov dx,puerto
  259.    asm int 14h
  260.    asm mov salida,ax
  261.    asm mov car,al
  262.    (*caracter)=car;
  263.    if (salida & (1<<15) ) return(0);
  264.    return(1);
  265. }// end lee_caracter
  266.  
  267. // --------------------------------------------------------------------
  268. // result = est_puerto(puerto);
  269. //
  270. // int result     --> Devuelve el estado del puerto de comunicación.
  271. // int puerto     --> Especifica de que puerto se obtiene el estado.
  272. //
  273. // Esta función retorna el estado del puerto de comunicacíón.
  274. // Para ello utiliza la interrupción 14 de la Bios, Subfunción (03h)
  275. int est_puerto(int puerto)
  276. {
  277.    int salida;
  278.    asm mov ah,03h
  279.    asm mov dx,puerto
  280.    asm int 14h
  281.    asm mov salida,ax
  282.    return(salida);
  283. }// end est_puerto
  284.  
  285.  
  286. /*
  287. main()
  288. {
  289.    int a;
  290.    char as=' ';
  291.    FILE  *handle;
  292.    handle=fopen("mio.txt","wt");
  293.    prep_comunicacion(COM2,_2400_BAUDIOS,_SIN_PARIDAD,_2_BIT_PARADA,_8_BITS_LONG_PALABRA);
  294.    do {
  295.       as = getch();
  296.       while(!env_caracter(COM2,as));
  297.    } while(as != 27) ;
  298.    fclose(handle);
  299.    return(0);
  300. }
  301. */
  302. #endif